Lambda the Ultimate

Hi all,
During recent weeks LtU changed its behaviour so much that I can hardly recognize it. Instead of focusing on the high quality items chosen by the contributing editors and posted to the homepage, most activity is in the forum which is starting to resemble comp.lang.misc. This change is partly the result of a couple of new and prolific members, but it seems many regulars enjoy these long threads, which to me seem rather pointless, and indeed want LtU to be more like USENET than like a group blog. I mentioned my concern in the specific threads I found problematic, so you can take a look and see the specific items I think are problematic for LtU.

As a recent message here said bluntly, LtU was created initially by me, but belongs to the entire community. This is not just true today: From early days I made sure LtU was a community site, and not my own personal playground. Thus, I feel reluctant to step in and end the threads that seem to me to be un-LtU like. I urge members to read our previous discussions about LtU's style and goals, including the suggestion that members publicly raise their concerns about items that seem inappropriate for LtU.

Due to my feelings regarding the current situation and similar concerns raised by others we are considering instituting several new measures.

One specific measure which we are considering adopting is that new forum topics posted by new members will be held for approval by moderators. The moderators could include the existing Contributing Editors, but we could also invite other respected LtU members to act as moderators, if it proves necessary. Note that this refers to items created using the "(new topic)" option. At this point we are not suggesting moderating comments on existing threads and homepage items. Members repeatedely violating our regular guidelines will be expelled or put on probation in the same way the happens today (a measure we adopted after the last round of etiquette discussions). This is an extreme measure and happens very rarely.

There's also a need for more explicit site policies, to help make it clear what is and isn't appropriate. This will help in ongoing moderation efforts, since in cases where a discussion is going off track, it is easier if an attempt at moderation can simply point to a specific, documented site policy. Any suggestions for site policies from LtU regulars are more than welcome, of course.

One policy which clearly seems needed is that we should try to avoid ungrounded discussions: discussions in which someone defends an idea that they haven't clearly described, and for which there are no existing references. We should not be playing "twenty questions" with people who haven't taken the trouble to express themselves clearly - it's unproductive, and tends to reduce the quality of discussion. LtU is best used to discuss ideas that were published and argued elsewhere. It is not usually a good place for design discussions and the like.

I'd like to hear what other members think. If long time members agree with me, and with the couple of other people who emailed their concern, I think it should be possible to return to the high quality of discussions we've come to expect on LtU. If, however, most members prefer the current situation, we will need to think carefully about the future direction and organization of the site.

Ehud

P.S
I remind readers that it is possible to simply read the homepage (I do it via RSS), and skip the LtU forum entirely.

This amusing discussion is coming up all over the place.

Notice that a language with slightly different semantics would "solve" this problem, or at least mitigate the problem: All you need is to have range constraints on integers, thus not allowing the numbers to overflow unnoticed. This is the standard out of the box behaviour of Ada, for example. So another way to view this is as a question of finding good default behaviour for programming languages (you can suppress the range checks in Ada, if you *really* want to).

Hi, I'd like to announce our paper "SuperGlue: Component Programming with Object-Oriented Signals," which will be presented at ECOOP next month. Its related to functional-reactive programming with a more declarative and object-oriented way of manipulating signals.

Abstract:

Abstract. The assembly of components that can handle continuously changing data results in programs that are more interactive. Unfortunately, the code that glues together such components is often difficult to write because it is exposed to many complicated event-handling details. This paper introduces the SuperGlue language where components are assembled by connecting their signals, which declaratively represent state as time-varying values. To support the construction of interactive programs that require an unbounded number of signal connections, signals in SuperGlue are scaled with object-oriented abstractions. With Super-Glue’s combination of signals and objects, programmers can build large interactive programs with substantially less glue code when compared to conventional approaches. For example, the SuperGlue implementation of an email client is around half the size of an equivalent Java implementation.

Paper available here here.

The ECMAScript group has created some public resources for the Edition 4 design and specification process. We've released a public export of the group wiki and started a public mailing list for discussion related to ECMAScript Edition 4.

Keep in mind this is an ongoing process, and we've preferred to release information early to integrate community feedback into the process. As a result the documents are not in their final state, and none of these documents should be considered authoritative yet.

You'll find most of the activity, and the most up-to-date material, in the proposals section. There's a fair bit of information under discussion and clarification as well.

Here's a small sample of proposals that members of LtU might find particularly interesting:

• proper tail calls
• iterators and generators
• let expressions
• optional type system
• continuation marks
• meta-objects

Recent research has shown how boilerplate code, or repetitive code for traversing datatypes, can be eliminated using generic programming techniques already available within some implementations of Haskell. One particularly intractable kind of boilerplate is nameplate, or code having to do with names, name-binding, and fresh name generation. One reason for the difficulty is that operations on data structures involving names, as usually implemented, are not regular instances of standard map, fold , or zip operations. However, in nominal abstract syntax, an alternative treatment of names and binding based on swapping, operations such as alpha-equivalence, capture-avoiding substitution, and free variable set functions are much better-behaved. In this paper, we show how nominal abstract syntax techniques similar to those of FreshML can be provided as a Haskell library called FreshLib. In addition, we show how existing generic programming techniques can be used to reduce the amount of nameplate code that needs to be written for new datatypes involving names and binding to almost nothing—in short, how to scrap your nameplate.

Nested commits for mobile calculi: extending Join
by Roberto Bruni, Hernan Melgratti, Ugo Montanari

In global computing applications the availability of a mechanism for some form of committed choice can be useful, and sometimes necessary. It can conveniently handle, e.g., contract stipulation, distributed agreements, and negotiations with nested choice points to be carried out concurrently. We propose a linguistic extension of the Join calculus for programming nested commits, called Committed Join (cJoin).
It provides primitives for explicit abort, programmable compensations and interactions between ongoing negotiations. We give the operational semantics of cJoin in the reflexive CHAM style. Then we discuss its expressiveness on the basis of a few examples and of the cJoin encoding of other paradigms with similar aims but designed in different contexts, namely AKL and Zero-Safe nets.

To me the main interest lies in section 4.2, which shows an encoding of a subset of AKL in cJoin.
More references to relationships between logic/constraint and "pi-family" approaches to concurrency are welcome!

Since we've been discussing hybrid type checking, dependent types, etc. recently...

Sage

Sage is a prototype functional programming language designed to provide high-coverage checking of expressive program specifications (types). Sage allows a programmer to specify not only simple types such as "Integers" and "Strings" but also arbitrary refinements from simple ranges such as "Positive Integers" to data structures with complex invariants such as "Balanced binary search trees." In addition to featuring these predicates upon types, Sage merges the syntactic categories of types and terms, in the spirit of Pure Type Systems, to express dependent types such as that of the infamous printf function.

Sage performs hybrid type checking of these specifications, proving or refuting as much as possible statically, and inserting runtime checks otherwise. For the complete details of the theory and empirical results, we direct you to the technical report.

This research workshop takes place in Israel, so I doubt many of you will come, but the program is quite interesting so you might want to google some of the titles...

Continuations for Parallel Logic Programming
by Eneia Todoran and Nikolaos S. Papaspyrou

This paper gives denotational models for three logic programming
languages of progressive complexity, adopting the
"logic programming without logic" approach. The first language
is the control ow kernel of sequential Prolog, featuring
sequential composition and backtracking. A committed-choice
concurrent logic language with parallel composition
(parallel AND) and don't care nondeterminism is studied
next. The third language is the core of Warren's basic Andorra
model, combining parallel composition and don't care
nondeterminism with two forms of don't know nondeterminism
(interpreted as sequential and parallel OR) and favoring
deterministic over nondeterministic computation. We show
that continuations are a valuable tool in the analysis and
design of semantic models for both sequential and parallel
logic programming. Instead of using mathematical notation,
we use the functional programming language Haskell
as a metalanguage for our denotational semantics, and employ
monads in order to facilitate the transition from one
language under study to another.

This paper happens to combine several topics that interest me lately - AKL (a precursor of Oz), denotational semantics, continuations, and implementing programming languages in Haskell.

If you share at least some of these interests - take a look!

Hop, A Language for Programming the Web 2.0

From the abstract:

"Hop is a new higher-order language designed for programming interactive web applications such as web agendas, web galleries, music players, etc. It exposes a programming model based on two computation levels. The first one is in charge of executing the logic of an application while the second one is in charge of executing the graphical user interface. Hop separates the logic and the graphical user interface but it packages them together and it supports strong collaborations between the two engines. The two execution flows communicate through function calls and event loops. Both ends can initiate communications."

It appears to be implemented in Scheme. The Hop website has a nice demo.